﻿namespace 战斗系统原型.数值处理.战斗数值计算
{
    internal static class 效果链路
    {
        //对于某个角色进行的某个伤害值，要经过的所有计算处理。
        public static Dictionary<角色, List<伤害效果>> 伤害效果链路 { get; set; } = new();
        public static Dictionary<角色, List<恢复效果>> 恢复效果链路 { get; set; } = new();
        public static int 计算伤害链路(角色 当前角色, 攻击属性 属性, int 伤害值)
        {
            if (!伤害效果链路.ContainsKey(当前角色)) { return 伤害值; }
            var 链路表 = 伤害效果链路[当前角色];
            链路表.Sort((前项, 后项) => 后项.效果优先级.CompareTo(前项.效果优先级));
            var 最终伤害值 = 伤害值;
            foreach (var 效果 in 链路表)
            {
                最终伤害值 = 效果.获取伤害值(当前角色,属性, 伤害值);
                if (效果.打断链路) { break; }
            }
            return 最终伤害值;
        }

        public static int 计算恢复链路(角色 当前角色, 攻击属性 属性, int 恢复值)
        {
            if (!恢复效果链路.ContainsKey(当前角色)) { return 恢复值; }
            var 链路表 = 恢复效果链路[当前角色];
            链路表.Sort((前项, 后项) => 后项.效果优先级.CompareTo(前项.效果优先级));
            var 最终恢复值 = 恢复值;
            foreach (var 效果 in 链路表)
            {
                最终恢复值 = 效果.获取恢复值(当前角色, 恢复值);
                if (效果.打断链路) { break; }
            }
            return 最终恢复值;
        }

        public static void 增加伤害效果链路(角色 目标角色, 攻击属性 属性, 伤害效果 效果)
        {
            if (!伤害效果链路.ContainsKey(目标角色)) { 伤害效果链路.Add(目标角色, new List<伤害效果>()); }
            伤害效果链路[目标角色].Add(效果);
        }
        public static void 增加恢复效果链路(角色 目标角色, 恢复效果 效果)
        {
            if (!恢复效果链路.ContainsKey(目标角色)) { 恢复效果链路.Add(目标角色, new List<恢复效果>()); }
            恢复效果链路[目标角色].Add(效果);
        }
    }

    public interface 伤害效果
    {
        /// <summary>
        /// 链路将调用此方法来计算伤害值，你需要将最后的伤害值返回，交由下一链路处理
        /// </summary>
        /// <param name="被伤害的角色">被伤害的角色实例</param>
        /// <param name="属性">伤害属性类型</param>
        /// <param name="传入的伤害值">之前的伤害值</param>
        /// <returns></returns>
        public int 获取伤害值(角色 被伤害的角色, 攻击属性 属性, int 传入的伤害值);
        /// <summary>
        /// 链路在调用此方法后是否要被打断，在执行获取伤害值后，将判断是否要到此打断链路，不再计算后续的效果。
        /// </summary>
        public bool 打断链路 { get; set; }
        /// <summary>
        /// 指定效果在链路中的优先级，若数值更高，则效果会先被执行
        /// </summary>
        public int 效果优先级 { get; set; }

    }
    public interface 恢复效果
    {
        /// <summary>
        /// 链路将调用此方法来计算恢复值，你需要将最后的恢复值返回，交由下一链路处理
        /// </summary>
        /// <param name="被恢复的角色">被恢复的角色实例</param>
        /// <param name="传入的恢复值">之前的恢复值</param>
        /// <returns></returns>
        public int 获取恢复值(角色 被恢复的角色, int 传入的恢复值);
        /// <summary>
        /// 链路在调用此方法后是否要被打断，在执行获取伤害值后，将判断是否要到此打断链路，不再计算后续的效果。
        /// </summary>
        public bool 打断链路 { get; set; }
        /// <summary>
        /// 指定效果在链路中的优先级，若数值更高，则效果会先被执行
        /// </summary>
        public int 效果优先级 { get; set; }

    }
}
